9 tools. Zero deps. One ecosystem.

Your team makes technical decisions on gut feel. It does not have to be that way.

grainulation turns questions into typed, evidence-graded claims and compiles them into decision briefs. Research that holds up to scrutiny.

grainulation is an ecosystem of nine command-line tools for structured technical research. You start with a question — "Should we migrate to GraphQL?" — and the tools guide you through research, adversarial challenge, and compilation into a decision brief.

Every finding is tracked as a typed claim with an evidence tier (from "someone said it" to "we measured it in production"). The system forces you to challenge your own assumptions before shipping a recommendation.

You need Claude Code, Node.js 20+, and npx. No accounts, no cloud services, no npm install. Everything runs locally, everything is plain JSON and HTML.


From question to shipped decision

Start with wheat. Add tools only when you need them. Most sprints need just the core engine.

Wheat
Research
Farmer
Permissions
Mill
Export
Harvest
Analytics
Barn
Shared utilities
Silo
Knowledge packs
Orchard
Orchestration

Three commands. One decision.

No install. No signup. Just npx and a question.

1

Initialize a sprint

Start with the question you need answered. wheat creates a claims file and config.

$ npx @grainulation/wheat init
Sprint initialized. claims.json created (0 claims) wheat.config.json ready
2

Research and challenge

Gather evidence, then stress-test it. Every finding becomes a typed, graded claim.

wheat> /research "topic"
wheat> /challenge r001
r001 [factual|documented] ... x001 [risk|documented] ...
3

Compile and ship

The compiler resolves conflicts, checks evidence, and produces a decision brief.

wheat> /brief
Compiled 12 claims (2 conflicts resolved) Written: output/brief.html

Question to decision in 10 minutes

A team needs to decide whether to migrate from REST to GraphQL. Here is the full sprint, start to finish.

$ npx @grainulation/wheat init Question: Should we migrate from REST to GraphQL? Audience: Backend team + mobile leads Constraints: Must support existing iOS/Android clients Sprint created. claims.json + wheat.config.json ready.
wheat> /research "GraphQL performance, migration cost, mobile payload" r001 [factual|documented] GraphQL reduces mobile payload 15-25% r002 [risk|documented] REST CDN caching doesn't transfer r003 [estimate|web] Migration effort: 3-5 weeks r004 [factual|documented] Apollo Client adds 35KB gzipped
wheat> /challenge r001 x001 [risk|documented] Payload reduction varies by endpoint — some REST responses already lean
wheat> /prototype p001 [factual|tested] Measured 18% reduction on /api/feed p002 [risk|tested] N+1 query problem on nested resolvers
wheat> /brief Compiled 8 claims (1 conflict resolved) Written: output/brief.html Recommendation: Adopt GraphQL for new endpoints only. Migrate existing REST endpoints opportunistically.

Nine tools. Each does one thing well.

Start with wheat. Everything else is optional. Add tools as your research practice grows.

Wheat
Research engine
The core. Ask a question, grow claims from multiple angles, compile a decision brief. Everything starts here.
npx @grainulation/wheat init
Farmer
Permission dashboard
Approve AI agent tool calls from your phone, another tab, or a meeting. Real-time SSE dashboard. Zero dependencies.
npx @grainulation/farmer start
Barn
Shared utilities
Sprint detection, manifest generation, HTML templates. The shared foundation the ecosystem builds on.
npx @grainulation/barn detect-sprints
Mill
Export and publish
Turn compiled research into PDFs, CSVs, and static sites. Every format you need to share decisions.
npx @grainulation/mill export --format pdf
Silo
Knowledge packs
Reusable claim libraries. HIPAA constraints, migration risks, architecture patterns. Pull established knowledge, skip the re-research.
npx @grainulation/silo pull compliance
Harvest
Analytics
Cross-sprint learning. Track prediction accuracy, find systemic blind spots, detect stale claims across all your research.
npx @grainulation/harvest analyze ./sprints/
Orchard
Multi-sprint orchestration
Multi-sprint coordination. Dependencies, conflict detection, team assignment. The org-wide view of all active research.
npx @grainulation/orchard status
Grainulator
Auto-sprint execution
The execution engine. Runs full research sprints autonomously — from question to compiled brief — with zero human intervention between steps.
npx @grainulation/grainulator run
Grainulation
Unified CLI
The meta-tool. Routes to the right tool, checks ecosystem health, manages configuration across all nine packages.
npx grainulation

Built on four principles

The decisions behind the tools.

Satisficing over maximizing

You will never have perfect information. The goal is enough evidence to make a defensible decision, not a perfect one.

Claims over opinions

Every finding is a typed claim with an evidence tier and provenance. "I think" becomes a traceable claim ID with a grade.

Adversarial pressure

Comfortable agreement is the enemy of good decisions. The system forces you to challenge, witness, and stress-test every claim.

Zero dependencies

Standard library only. No supply chain anxiety. No left-pad. Every tool ships what it needs and nothing more.


Common questions

Do I need Node.js?

Yes. Node.js 20+ is required. That is the only system dependency. Everything runs via npx with zero npm install required — packages are fetched and cached automatically.

Does this work with my programming language / framework?

grainulation is language-agnostic. It researches decisions about any technology — databases, APIs, infrastructure, architecture. The tools run locally, but the research can be about anything.

How does this compare to writing an RFC or ADR?

RFCs and ADRs document a decision after it is made. grainulation captures the research process — the evidence gathering, adversarial testing, and conflict resolution that leads to the decision. The output brief can serve as your ADR.

Do I need all nine tools?

No. Start with wheat alone — it handles the full research-to-decision workflow. Add other tools only when you need specific capabilities: farmer for AI permissions, mill for export, silo for reusable knowledge, and so on.